home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 19 / Mac Magazin and MacEasy Magazine CD - Issue 19.iso / Utilities / uae-0.4 / Source Code / CPU Sources / cpu9.c < prev    next >
C/C++ Source or Header  |  1996-02-13  |  43KB  |  1,404 lines
  1. #include "config.h"
  2. #include "amiga.h"
  3. #include "options.h"
  4. #include <stdlib.h>
  5. #include "memory.h"
  6. #include "custom.h"
  7. #include "newcpu.h"
  8. #include "cputbl.h"
  9. void op_9000(UWORD opcode)
  10. {
  11.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  12.     ULONG dstreg = (opcode & 3584) >> 9;
  13. {{    BYTE src = regs.d[srcreg];
  14. {    BYTE dst = regs.d[dstreg];
  15. {    ULONG newv = dst - src;
  16. {    bool flgs = ((BYTE)(src)) < 0;
  17.     bool flgo = ((BYTE)(dst)) < 0;
  18.     bool flgn = ((BYTE)(newv)) < 0;
  19.     regs.z = ((BYTE)(newv)) == 0;
  20.     regs.v = (flgs != flgo) && (flgn != flgo);
  21.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  22.     regs.n = flgn != 0;
  23.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  24. }}}}}}
  25. void op_9010(UWORD opcode)
  26. {
  27.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  28.     ULONG dstreg = (opcode & 3584) >> 9;
  29. {{    CPTR srca = regs.a[srcreg];
  30.     BYTE src = get_byte(srca);
  31. {    BYTE dst = regs.d[dstreg];
  32. {    ULONG newv = dst - src;
  33. {    bool flgs = ((BYTE)(src)) < 0;
  34.     bool flgo = ((BYTE)(dst)) < 0;
  35.     bool flgn = ((BYTE)(newv)) < 0;
  36.     regs.z = ((BYTE)(newv)) == 0;
  37.     regs.v = (flgs != flgo) && (flgn != flgo);
  38.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  39.     regs.n = flgn != 0;
  40.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  41. }}}}}}
  42. void op_9018(UWORD opcode)
  43. {
  44.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  45.     ULONG dstreg = (opcode & 3584) >> 9;
  46. {{    CPTR srca = regs.a[srcreg];
  47.     BYTE src = get_byte(srca);
  48. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  49. {    BYTE dst = regs.d[dstreg];
  50. {    ULONG newv = dst - src;
  51. {    bool flgs = ((BYTE)(src)) < 0;
  52.     bool flgo = ((BYTE)(dst)) < 0;
  53.     bool flgn = ((BYTE)(newv)) < 0;
  54.     regs.z = ((BYTE)(newv)) == 0;
  55.     regs.v = (flgs != flgo) && (flgn != flgo);
  56.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  57.     regs.n = flgn != 0;
  58.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  59. }}}}}}}
  60. void op_9020(UWORD opcode)
  61. {
  62.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  63.     ULONG dstreg = (opcode & 3584) >> 9;
  64. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  65. {    CPTR srca = regs.a[srcreg];
  66.     BYTE src = get_byte(srca);
  67. {    BYTE dst = regs.d[dstreg];
  68. {    ULONG newv = dst - src;
  69. {    bool flgs = ((BYTE)(src)) < 0;
  70.     bool flgo = ((BYTE)(dst)) < 0;
  71.     bool flgn = ((BYTE)(newv)) < 0;
  72.     regs.z = ((BYTE)(newv)) == 0;
  73.     regs.v = (flgs != flgo) && (flgn != flgo);
  74.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  75.     regs.n = flgn != 0;
  76.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  77. }}}}}}}
  78. void op_9028(UWORD opcode)
  79. {
  80.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  81.     ULONG dstreg = (opcode & 3584) >> 9;
  82. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  83.     BYTE src = get_byte(srca);
  84. {    BYTE dst = regs.d[dstreg];
  85. {    ULONG newv = dst - src;
  86. {    bool flgs = ((BYTE)(src)) < 0;
  87.     bool flgo = ((BYTE)(dst)) < 0;
  88.     bool flgn = ((BYTE)(newv)) < 0;
  89.     regs.z = ((BYTE)(newv)) == 0;
  90.     regs.v = (flgs != flgo) && (flgn != flgo);
  91.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  92.     regs.n = flgn != 0;
  93.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  94. }}}}}}
  95. void op_9030(UWORD opcode)
  96. {
  97.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  98.     ULONG dstreg = (opcode & 3584) >> 9;
  99. {{    CPTR srca = regs.a[srcreg];
  100.     UWORD srcdp = nextiword();
  101.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  102. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  103.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  104.     srca += srcdpr;
  105. {    BYTE src = get_byte(srca);
  106. {    BYTE dst = regs.d[dstreg];
  107. {    ULONG newv = dst - src;
  108. {    bool flgs = ((BYTE)(src)) < 0;
  109.     bool flgo = ((BYTE)(dst)) < 0;
  110.     bool flgn = ((BYTE)(newv)) < 0;
  111.     regs.z = ((BYTE)(newv)) == 0;
  112.     regs.v = (flgs != flgo) && (flgn != flgo);
  113.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  114.     regs.n = flgn != 0;
  115.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  116. }}}}}}}}
  117. void op_9038(UWORD opcode)
  118. {
  119.     ULONG dstreg = (opcode & 3584) >> 9;
  120. {{    CPTR srca = (LONG)(WORD)nextiword();
  121.     BYTE src = get_byte(srca);
  122. {    BYTE dst = regs.d[dstreg];
  123. {    ULONG newv = dst - src;
  124. {    bool flgs = ((BYTE)(src)) < 0;
  125.     bool flgo = ((BYTE)(dst)) < 0;
  126.     bool flgn = ((BYTE)(newv)) < 0;
  127.     regs.z = ((BYTE)(newv)) == 0;
  128.     regs.v = (flgs != flgo) && (flgn != flgo);
  129.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  130.     regs.n = flgn != 0;
  131.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  132. }}}}}}
  133. void op_9039(UWORD opcode)
  134. {
  135.     ULONG dstreg = (opcode & 3584) >> 9;
  136. {{    CPTR srca = nextilong();
  137.     BYTE src = get_byte(srca);
  138. {    BYTE dst = regs.d[dstreg];
  139. {    ULONG newv = dst - src;
  140. {    bool flgs = ((BYTE)(src)) < 0;
  141.     bool flgo = ((BYTE)(dst)) < 0;
  142.     bool flgn = ((BYTE)(newv)) < 0;
  143.     regs.z = ((BYTE)(newv)) == 0;
  144.     regs.v = (flgs != flgo) && (flgn != flgo);
  145.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  146.     regs.n = flgn != 0;
  147.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  148. }}}}}}
  149. void op_903a(UWORD opcode)
  150. {
  151.     ULONG dstreg = (opcode & 3584) >> 9;
  152. {{    CPTR srca = m68k_getpc();
  153.     srca += (LONG)(WORD)nextiword();
  154. {    BYTE src = get_byte(srca);
  155. {    BYTE dst = regs.d[dstreg];
  156. {    ULONG newv = dst - src;
  157. {    bool flgs = ((BYTE)(src)) < 0;
  158.     bool flgo = ((BYTE)(dst)) < 0;
  159.     bool flgn = ((BYTE)(newv)) < 0;
  160.     regs.z = ((BYTE)(newv)) == 0;
  161.     regs.v = (flgs != flgo) && (flgn != flgo);
  162.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  163.     regs.n = flgn != 0;
  164.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  165. }}}}}}}
  166. void op_903b(UWORD opcode)
  167. {
  168.     ULONG dstreg = (opcode & 3584) >> 9;
  169. {{    CPTR srca = m68k_getpc();
  170.     UWORD srcdp = nextiword();
  171.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  172. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  173.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  174.     srca += srcdpr;
  175. {    BYTE src = get_byte(srca);
  176. {    BYTE dst = regs.d[dstreg];
  177. {    ULONG newv = dst - src;
  178. {    bool flgs = ((BYTE)(src)) < 0;
  179.     bool flgo = ((BYTE)(dst)) < 0;
  180.     bool flgn = ((BYTE)(newv)) < 0;
  181.     regs.z = ((BYTE)(newv)) == 0;
  182.     regs.v = (flgs != flgo) && (flgn != flgo);
  183.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  184.     regs.n = flgn != 0;
  185.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  186. }}}}}}}}
  187. void op_903c(UWORD opcode)
  188. {
  189.     ULONG dstreg = (opcode & 3584) >> 9;
  190. {{    BYTE src = nextiword();
  191. {    BYTE dst = regs.d[dstreg];
  192. {    ULONG newv = dst - src;
  193. {    bool flgs = ((BYTE)(src)) < 0;
  194.     bool flgo = ((BYTE)(dst)) < 0;
  195.     bool flgn = ((BYTE)(newv)) < 0;
  196.     regs.z = ((BYTE)(newv)) == 0;
  197.     regs.v = (flgs != flgo) && (flgn != flgo);
  198.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  199.     regs.n = flgn != 0;
  200.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  201. }}}}}}
  202. void op_9040(UWORD opcode)
  203. {
  204.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  205.     ULONG dstreg = (opcode & 3584) >> 9;
  206. {{    WORD src = regs.d[srcreg];
  207. {    WORD dst = regs.d[dstreg];
  208. {    ULONG newv = dst - src;
  209. {    bool flgs = ((WORD)(src)) < 0;
  210.     bool flgo = ((WORD)(dst)) < 0;
  211.     bool flgn = ((WORD)(newv)) < 0;
  212.     regs.z = ((WORD)(newv)) == 0;
  213.     regs.v = (flgs != flgo) && (flgn != flgo);
  214.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  215.     regs.n = flgn != 0;
  216.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  217. }}}}}}
  218. void op_9048(UWORD opcode)
  219. {
  220.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  221.     ULONG dstreg = (opcode & 3584) >> 9;
  222. {{    WORD src = regs.a[srcreg];
  223. {    WORD dst = regs.d[dstreg];
  224. {    ULONG newv = dst - src;
  225. {    bool flgs = ((WORD)(src)) < 0;
  226.     bool flgo = ((WORD)(dst)) < 0;
  227.     bool flgn = ((WORD)(newv)) < 0;
  228.     regs.z = ((WORD)(newv)) == 0;
  229.     regs.v = (flgs != flgo) && (flgn != flgo);
  230.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  231.     regs.n = flgn != 0;
  232.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  233. }}}}}}
  234. void op_9050(UWORD opcode)
  235. {
  236.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  237.     ULONG dstreg = (opcode & 3584) >> 9;
  238. {{    CPTR srca = regs.a[srcreg];
  239.     WORD src = get_word(srca);
  240. {    WORD dst = regs.d[dstreg];
  241. {    ULONG newv = dst - src;
  242. {    bool flgs = ((WORD)(src)) < 0;
  243.     bool flgo = ((WORD)(dst)) < 0;
  244.     bool flgn = ((WORD)(newv)) < 0;
  245.     regs.z = ((WORD)(newv)) == 0;
  246.     regs.v = (flgs != flgo) && (flgn != flgo);
  247.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  248.     regs.n = flgn != 0;
  249.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  250. }}}}}}
  251. void op_9058(UWORD opcode)
  252. {
  253.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  254.     ULONG dstreg = (opcode & 3584) >> 9;
  255. {{    CPTR srca = regs.a[srcreg];
  256.     WORD src = get_word(srca);
  257. {    regs.a[srcreg] += 2;
  258. {    WORD dst = regs.d[dstreg];
  259. {    ULONG newv = dst - src;
  260. {    bool flgs = ((WORD)(src)) < 0;
  261.     bool flgo = ((WORD)(dst)) < 0;
  262.     bool flgn = ((WORD)(newv)) < 0;
  263.     regs.z = ((WORD)(newv)) == 0;
  264.     regs.v = (flgs != flgo) && (flgn != flgo);
  265.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  266.     regs.n = flgn != 0;
  267.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  268. }}}}}}}
  269. void op_9060(UWORD opcode)
  270. {
  271.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  272.     ULONG dstreg = (opcode & 3584) >> 9;
  273. {{    regs.a[srcreg] -= 2;
  274. {    CPTR srca = regs.a[srcreg];
  275.     WORD src = get_word(srca);
  276. {    WORD dst = regs.d[dstreg];
  277. {    ULONG newv = dst - src;
  278. {    bool flgs = ((WORD)(src)) < 0;
  279.     bool flgo = ((WORD)(dst)) < 0;
  280.     bool flgn = ((WORD)(newv)) < 0;
  281.     regs.z = ((WORD)(newv)) == 0;
  282.     regs.v = (flgs != flgo) && (flgn != flgo);
  283.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  284.     regs.n = flgn != 0;
  285.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  286. }}}}}}}
  287. void op_9068(UWORD opcode)
  288. {
  289.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  290.     ULONG dstreg = (opcode & 3584) >> 9;
  291. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  292.     WORD src = get_word(srca);
  293. {    WORD dst = regs.d[dstreg];
  294. {    ULONG newv = dst - src;
  295. {    bool flgs = ((WORD)(src)) < 0;
  296.     bool flgo = ((WORD)(dst)) < 0;
  297.     bool flgn = ((WORD)(newv)) < 0;
  298.     regs.z = ((WORD)(newv)) == 0;
  299.     regs.v = (flgs != flgo) && (flgn != flgo);
  300.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  301.     regs.n = flgn != 0;
  302.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  303. }}}}}}
  304. void op_9070(UWORD opcode)
  305. {
  306.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  307.     ULONG dstreg = (opcode & 3584) >> 9;
  308. {{    CPTR srca = regs.a[srcreg];
  309.     UWORD srcdp = nextiword();
  310.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  311. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  312.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  313.     srca += srcdpr;
  314. {    WORD src = get_word(srca);
  315. {    WORD dst = regs.d[dstreg];
  316. {    ULONG newv = dst - src;
  317. {    bool flgs = ((WORD)(src)) < 0;
  318.     bool flgo = ((WORD)(dst)) < 0;
  319.     bool flgn = ((WORD)(newv)) < 0;
  320.     regs.z = ((WORD)(newv)) == 0;
  321.     regs.v = (flgs != flgo) && (flgn != flgo);
  322.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  323.     regs.n = flgn != 0;
  324.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  325. }}}}}}}}
  326. void op_9078(UWORD opcode)
  327. {
  328.     ULONG dstreg = (opcode & 3584) >> 9;
  329. {{    CPTR srca = (LONG)(WORD)nextiword();
  330.     WORD src = get_word(srca);
  331. {    WORD dst = regs.d[dstreg];
  332. {    ULONG newv = dst - src;
  333. {    bool flgs = ((WORD)(src)) < 0;
  334.     bool flgo = ((WORD)(dst)) < 0;
  335.     bool flgn = ((WORD)(newv)) < 0;
  336.     regs.z = ((WORD)(newv)) == 0;
  337.     regs.v = (flgs != flgo) && (flgn != flgo);
  338.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  339.     regs.n = flgn != 0;
  340.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  341. }}}}}}
  342. void op_9079(UWORD opcode)
  343. {
  344.     ULONG dstreg = (opcode & 3584) >> 9;
  345. {{    CPTR srca = nextilong();
  346.     WORD src = get_word(srca);
  347. {    WORD dst = regs.d[dstreg];
  348. {    ULONG newv = dst - src;
  349. {    bool flgs = ((WORD)(src)) < 0;
  350.     bool flgo = ((WORD)(dst)) < 0;
  351.     bool flgn = ((WORD)(newv)) < 0;
  352.     regs.z = ((WORD)(newv)) == 0;
  353.     regs.v = (flgs != flgo) && (flgn != flgo);
  354.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  355.     regs.n = flgn != 0;
  356.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  357. }}}}}}
  358. void op_907a(UWORD opcode)
  359. {
  360.     ULONG dstreg = (opcode & 3584) >> 9;
  361. {{    CPTR srca = m68k_getpc();
  362.     srca += (LONG)(WORD)nextiword();
  363. {    WORD src = get_word(srca);
  364. {    WORD dst = regs.d[dstreg];
  365. {    ULONG newv = dst - src;
  366. {    bool flgs = ((WORD)(src)) < 0;
  367.     bool flgo = ((WORD)(dst)) < 0;
  368.     bool flgn = ((WORD)(newv)) < 0;
  369.     regs.z = ((WORD)(newv)) == 0;
  370.     regs.v = (flgs != flgo) && (flgn != flgo);
  371.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  372.     regs.n = flgn != 0;
  373.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  374. }}}}}}}
  375. void op_907b(UWORD opcode)
  376. {
  377.     ULONG dstreg = (opcode & 3584) >> 9;
  378. {{    CPTR srca = m68k_getpc();
  379.     UWORD srcdp = nextiword();
  380.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  381. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  382.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  383.     srca += srcdpr;
  384. {    WORD src = get_word(srca);
  385. {    WORD dst = regs.d[dstreg];
  386. {    ULONG newv = dst - src;
  387. {    bool flgs = ((WORD)(src)) < 0;
  388.     bool flgo = ((WORD)(dst)) < 0;
  389.     bool flgn = ((WORD)(newv)) < 0;
  390.     regs.z = ((WORD)(newv)) == 0;
  391.     regs.v = (flgs != flgo) && (flgn != flgo);
  392.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  393.     regs.n = flgn != 0;
  394.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  395. }}}}}}}}
  396. void op_907c(UWORD opcode)
  397. {
  398.     ULONG dstreg = (opcode & 3584) >> 9;
  399. {{    WORD src = nextiword();
  400. {    WORD dst = regs.d[dstreg];
  401. {    ULONG newv = dst - src;
  402. {    bool flgs = ((WORD)(src)) < 0;
  403.     bool flgo = ((WORD)(dst)) < 0;
  404.     bool flgn = ((WORD)(newv)) < 0;
  405.     regs.z = ((WORD)(newv)) == 0;
  406.     regs.v = (flgs != flgo) && (flgn != flgo);
  407.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  408.     regs.n = flgn != 0;
  409.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  410. }}}}}}
  411. void op_9080(UWORD opcode)
  412. {
  413.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  414.     ULONG dstreg = (opcode & 3584) >> 9;
  415. {{    LONG src = regs.d[srcreg];
  416. {    LONG dst = regs.d[dstreg];
  417. {    ULONG newv = dst - src;
  418. {    bool flgs = ((LONG)(src)) < 0;
  419.     bool flgo = ((LONG)(dst)) < 0;
  420.     bool flgn = ((LONG)(newv)) < 0;
  421.     regs.z = ((LONG)(newv)) == 0;
  422.     regs.v = (flgs != flgo) && (flgn != flgo);
  423.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  424.     regs.n = flgn != 0;
  425.     regs.d[dstreg] = (newv);
  426. }}}}}}
  427. void op_9088(UWORD opcode)
  428. {
  429.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  430.     ULONG dstreg = (opcode & 3584) >> 9;
  431. {{    LONG src = regs.a[srcreg];
  432. {    LONG dst = regs.d[dstreg];
  433. {    ULONG newv = dst - src;
  434. {    bool flgs = ((LONG)(src)) < 0;
  435.     bool flgo = ((LONG)(dst)) < 0;
  436.     bool flgn = ((LONG)(newv)) < 0;
  437.     regs.z = ((LONG)(newv)) == 0;
  438.     regs.v = (flgs != flgo) && (flgn != flgo);
  439.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  440.     regs.n = flgn != 0;
  441.     regs.d[dstreg] = (newv);
  442. }}}}}}
  443. void op_9090(UWORD opcode)
  444. {
  445.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  446.     ULONG dstreg = (opcode & 3584) >> 9;
  447. {{    CPTR srca = regs.a[srcreg];
  448.     LONG src = get_long(srca);
  449. {    LONG dst = regs.d[dstreg];
  450. {    ULONG newv = dst - src;
  451. {    bool flgs = ((LONG)(src)) < 0;
  452.     bool flgo = ((LONG)(dst)) < 0;
  453.     bool flgn = ((LONG)(newv)) < 0;
  454.     regs.z = ((LONG)(newv)) == 0;
  455.     regs.v = (flgs != flgo) && (flgn != flgo);
  456.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  457.     regs.n = flgn != 0;
  458.     regs.d[dstreg] = (newv);
  459. }}}}}}
  460. void op_9098(UWORD opcode)
  461. {
  462.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  463.     ULONG dstreg = (opcode & 3584) >> 9;
  464. {{    CPTR srca = regs.a[srcreg];
  465.     LONG src = get_long(srca);
  466. {    regs.a[srcreg] += 4;
  467. {    LONG dst = regs.d[dstreg];
  468. {    ULONG newv = dst - src;
  469. {    bool flgs = ((LONG)(src)) < 0;
  470.     bool flgo = ((LONG)(dst)) < 0;
  471.     bool flgn = ((LONG)(newv)) < 0;
  472.     regs.z = ((LONG)(newv)) == 0;
  473.     regs.v = (flgs != flgo) && (flgn != flgo);
  474.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  475.     regs.n = flgn != 0;
  476.     regs.d[dstreg] = (newv);
  477. }}}}}}}
  478. void op_90a0(UWORD opcode)
  479. {
  480.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  481.     ULONG dstreg = (opcode & 3584) >> 9;
  482. {{    regs.a[srcreg] -= 4;
  483. {    CPTR srca = regs.a[srcreg];
  484.     LONG src = get_long(srca);
  485. {    LONG dst = regs.d[dstreg];
  486. {    ULONG newv = dst - src;
  487. {    bool flgs = ((LONG)(src)) < 0;
  488.     bool flgo = ((LONG)(dst)) < 0;
  489.     bool flgn = ((LONG)(newv)) < 0;
  490.     regs.z = ((LONG)(newv)) == 0;
  491.     regs.v = (flgs != flgo) && (flgn != flgo);
  492.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  493.     regs.n = flgn != 0;
  494.     regs.d[dstreg] = (newv);
  495. }}}}}}}
  496. void op_90a8(UWORD opcode)
  497. {
  498.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  499.     ULONG dstreg = (opcode & 3584) >> 9;
  500. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  501.     LONG src = get_long(srca);
  502. {    LONG dst = regs.d[dstreg];
  503. {    ULONG newv = dst - src;
  504. {    bool flgs = ((LONG)(src)) < 0;
  505.     bool flgo = ((LONG)(dst)) < 0;
  506.     bool flgn = ((LONG)(newv)) < 0;
  507.     regs.z = ((LONG)(newv)) == 0;
  508.     regs.v = (flgs != flgo) && (flgn != flgo);
  509.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  510.     regs.n = flgn != 0;
  511.     regs.d[dstreg] = (newv);
  512. }}}}}}
  513. void op_90b0(UWORD opcode)
  514. {
  515.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  516.     ULONG dstreg = (opcode & 3584) >> 9;
  517. {{    CPTR srca = regs.a[srcreg];
  518.     UWORD srcdp = nextiword();
  519.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  520. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  521.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  522.     srca += srcdpr;
  523. {    LONG src = get_long(srca);
  524. {    LONG dst = regs.d[dstreg];
  525. {    ULONG newv = dst - src;
  526. {    bool flgs = ((LONG)(src)) < 0;
  527.     bool flgo = ((LONG)(dst)) < 0;
  528.     bool flgn = ((LONG)(newv)) < 0;
  529.     regs.z = ((LONG)(newv)) == 0;
  530.     regs.v = (flgs != flgo) && (flgn != flgo);
  531.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  532.     regs.n = flgn != 0;
  533.     regs.d[dstreg] = (newv);
  534. }}}}}}}}
  535. void op_90b8(UWORD opcode)
  536. {
  537.     ULONG dstreg = (opcode & 3584) >> 9;
  538. {{    CPTR srca = (LONG)(WORD)nextiword();
  539.     LONG src = get_long(srca);
  540. {    LONG dst = regs.d[dstreg];
  541. {    ULONG newv = dst - src;
  542. {    bool flgs = ((LONG)(src)) < 0;
  543.     bool flgo = ((LONG)(dst)) < 0;
  544.     bool flgn = ((LONG)(newv)) < 0;
  545.     regs.z = ((LONG)(newv)) == 0;
  546.     regs.v = (flgs != flgo) && (flgn != flgo);
  547.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  548.     regs.n = flgn != 0;
  549.     regs.d[dstreg] = (newv);
  550. }}}}}}
  551. void op_90b9(UWORD opcode)
  552. {
  553.     ULONG dstreg = (opcode & 3584) >> 9;
  554. {{    CPTR srca = nextilong();
  555.     LONG src = get_long(srca);
  556. {    LONG dst = regs.d[dstreg];
  557. {    ULONG newv = dst - src;
  558. {    bool flgs = ((LONG)(src)) < 0;
  559.     bool flgo = ((LONG)(dst)) < 0;
  560.     bool flgn = ((LONG)(newv)) < 0;
  561.     regs.z = ((LONG)(newv)) == 0;
  562.     regs.v = (flgs != flgo) && (flgn != flgo);
  563.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  564.     regs.n = flgn != 0;
  565.     regs.d[dstreg] = (newv);
  566. }}}}}}
  567. void op_90ba(UWORD opcode)
  568. {
  569.     ULONG dstreg = (opcode & 3584) >> 9;
  570. {{    CPTR srca = m68k_getpc();
  571.     srca += (LONG)(WORD)nextiword();
  572. {    LONG src = get_long(srca);
  573. {    LONG dst = regs.d[dstreg];
  574. {    ULONG newv = dst - src;
  575. {    bool flgs = ((LONG)(src)) < 0;
  576.     bool flgo = ((LONG)(dst)) < 0;
  577.     bool flgn = ((LONG)(newv)) < 0;
  578.     regs.z = ((LONG)(newv)) == 0;
  579.     regs.v = (flgs != flgo) && (flgn != flgo);
  580.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  581.     regs.n = flgn != 0;
  582.     regs.d[dstreg] = (newv);
  583. }}}}}}}
  584. void op_90bb(UWORD opcode)
  585. {
  586.     ULONG dstreg = (opcode & 3584) >> 9;
  587. {{    CPTR srca = m68k_getpc();
  588.     UWORD srcdp = nextiword();
  589.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  590. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  591.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  592.     srca += srcdpr;
  593. {    LONG src = get_long(srca);
  594. {    LONG dst = regs.d[dstreg];
  595. {    ULONG newv = dst - src;
  596. {    bool flgs = ((LONG)(src)) < 0;
  597.     bool flgo = ((LONG)(dst)) < 0;
  598.     bool flgn = ((LONG)(newv)) < 0;
  599.     regs.z = ((LONG)(newv)) == 0;
  600.     regs.v = (flgs != flgo) && (flgn != flgo);
  601.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  602.     regs.n = flgn != 0;
  603.     regs.d[dstreg] = (newv);
  604. }}}}}}}}
  605. void op_90bc(UWORD opcode)
  606. {
  607.     ULONG dstreg = (opcode & 3584) >> 9;
  608. {{    LONG src = nextilong();
  609. {    LONG dst = regs.d[dstreg];
  610. {    ULONG newv = dst - src;
  611. {    bool flgs = ((LONG)(src)) < 0;
  612.     bool flgo = ((LONG)(dst)) < 0;
  613.     bool flgn = ((LONG)(newv)) < 0;
  614.     regs.z = ((LONG)(newv)) == 0;
  615.     regs.v = (flgs != flgo) && (flgn != flgo);
  616.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  617.     regs.n = flgn != 0;
  618.     regs.d[dstreg] = (newv);
  619. }}}}}}
  620. void op_90c0(UWORD opcode)
  621. {
  622.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  623.     ULONG dstreg = (opcode & 3584) >> 9;
  624. {{    WORD src = regs.d[srcreg];
  625. {    LONG dst = regs.a[dstreg];
  626. {    ULONG newv = dst - src;
  627.     regs.a[dstreg] = (newv);
  628. }}}}}
  629. void op_90c8(UWORD opcode)
  630. {
  631.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  632.     ULONG dstreg = (opcode & 3584) >> 9;
  633. {{    WORD src = regs.a[srcreg];
  634. {    LONG dst = regs.a[dstreg];
  635. {    ULONG newv = dst - src;
  636.     regs.a[dstreg] = (newv);
  637. }}}}}
  638. void op_90d0(UWORD opcode)
  639. {
  640.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  641.     ULONG dstreg = (opcode & 3584) >> 9;
  642. {{    CPTR srca = regs.a[srcreg];
  643.     WORD src = get_word(srca);
  644. {    LONG dst = regs.a[dstreg];
  645. {    ULONG newv = dst - src;
  646.     regs.a[dstreg] = (newv);
  647. }}}}}
  648. void op_90d8(UWORD opcode)
  649. {
  650.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  651.     ULONG dstreg = (opcode & 3584) >> 9;
  652. {{    CPTR srca = regs.a[srcreg];
  653.     WORD src = get_word(srca);
  654. {    regs.a[srcreg] += 2;
  655. {    LONG dst = regs.a[dstreg];
  656. {    ULONG newv = dst - src;
  657.     regs.a[dstreg] = (newv);
  658. }}}}}}
  659. void op_90e0(UWORD opcode)
  660. {
  661.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  662.     ULONG dstreg = (opcode & 3584) >> 9;
  663. {{    regs.a[srcreg] -= 2;
  664. {    CPTR srca = regs.a[srcreg];
  665.     WORD src = get_word(srca);
  666. {    LONG dst = regs.a[dstreg];
  667. {    ULONG newv = dst - src;
  668.     regs.a[dstreg] = (newv);
  669. }}}}}}
  670. void op_90e8(UWORD opcode)
  671. {
  672.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  673.     ULONG dstreg = (opcode & 3584) >> 9;
  674. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  675.     WORD src = get_word(srca);
  676. {    LONG dst = regs.a[dstreg];
  677. {    ULONG newv = dst - src;
  678.     regs.a[dstreg] = (newv);
  679. }}}}}
  680. void op_90f0(UWORD opcode)
  681. {
  682.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  683.     ULONG dstreg = (opcode & 3584) >> 9;
  684. {{    CPTR srca = regs.a[srcreg];
  685.     UWORD srcdp = nextiword();
  686.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  687. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  688.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  689.     srca += srcdpr;
  690. {    WORD src = get_word(srca);
  691. {    LONG dst = regs.a[dstreg];
  692. {    ULONG newv = dst - src;
  693.     regs.a[dstreg] = (newv);
  694. }}}}}}}
  695. void op_90f8(UWORD opcode)
  696. {
  697.     ULONG dstreg = (opcode & 3584) >> 9;
  698. {{    CPTR srca = (LONG)(WORD)nextiword();
  699.     WORD src = get_word(srca);
  700. {    LONG dst = regs.a[dstreg];
  701. {    ULONG newv = dst - src;
  702.     regs.a[dstreg] = (newv);
  703. }}}}}
  704. void op_90f9(UWORD opcode)
  705. {
  706.     ULONG dstreg = (opcode & 3584) >> 9;
  707. {{    CPTR srca = nextilong();
  708.     WORD src = get_word(srca);
  709. {    LONG dst = regs.a[dstreg];
  710. {    ULONG newv = dst - src;
  711.     regs.a[dstreg] = (newv);
  712. }}}}}
  713. void op_90fa(UWORD opcode)
  714. {
  715.     ULONG dstreg = (opcode & 3584) >> 9;
  716. {{    CPTR srca = m68k_getpc();
  717.     srca += (LONG)(WORD)nextiword();
  718. {    WORD src = get_word(srca);
  719. {    LONG dst = regs.a[dstreg];
  720. {    ULONG newv = dst - src;
  721.     regs.a[dstreg] = (newv);
  722. }}}}}}
  723. void op_90fb(UWORD opcode)
  724. {
  725.     ULONG dstreg = (opcode & 3584) >> 9;
  726. {{    CPTR srca = m68k_getpc();
  727.     UWORD srcdp = nextiword();
  728.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  729. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  730.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  731.     srca += srcdpr;
  732. {    WORD src = get_word(srca);
  733. {    LONG dst = regs.a[dstreg];
  734. {    ULONG newv = dst - src;
  735.     regs.a[dstreg] = (newv);
  736. }}}}}}}
  737. void op_90fc(UWORD opcode)
  738. {
  739.     ULONG dstreg = (opcode & 3584) >> 9;
  740. {{    WORD src = nextiword();
  741. {    LONG dst = regs.a[dstreg];
  742. {    ULONG newv = dst - src;
  743.     regs.a[dstreg] = (newv);
  744. }}}}}
  745. void op_9100(UWORD opcode)
  746. {
  747.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  748.     ULONG dstreg = (opcode & 3584) >> 9;
  749. {{    BYTE src = regs.d[srcreg];
  750. {    BYTE dst = regs.d[dstreg];
  751. {    bool xflg = regs.x;
  752.     regs.v = regs.c = regs.x = 0;
  753. {    ULONG newv = dst - src;
  754. {    bool flgs = ((BYTE)(src)) < 0;
  755.     bool flgo = ((BYTE)(dst)) < 0;
  756.     bool flgn = ((BYTE)(newv)) < 0;
  757.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  758.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  759.     if (xflg)
  760. {{    bool flgs = ((BYTE)(1)) < 0;
  761.     bool flgo = ((BYTE)(newv)) < 0;
  762.     bool flgn = ((BYTE)((newv-1))) < 0;
  763.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  764.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  765.     newv--;
  766. }}    regs.z = ((BYTE)(newv)) == 0;
  767.     regs.n = ((BYTE)(newv)) < 0;
  768.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  769. }}}}}}}
  770. void op_9108(UWORD opcode)
  771. {
  772.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  773.     ULONG dstreg = (opcode & 3584) >> 9;
  774. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  775. {    CPTR srca = regs.a[srcreg];
  776.     BYTE src = get_byte(srca);
  777. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  778. {    CPTR dsta = regs.a[dstreg];
  779.     BYTE dst = get_byte(dsta);
  780. {    bool xflg = regs.x;
  781.     regs.v = regs.c = regs.x = 0;
  782. {    ULONG newv = dst - src;
  783. {    bool flgs = ((BYTE)(src)) < 0;
  784.     bool flgo = ((BYTE)(dst)) < 0;
  785.     bool flgn = ((BYTE)(newv)) < 0;
  786.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  787.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  788.     if (xflg)
  789. {{    bool flgs = ((BYTE)(1)) < 0;
  790.     bool flgo = ((BYTE)(newv)) < 0;
  791.     bool flgn = ((BYTE)((newv-1))) < 0;
  792.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  793.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  794.     newv--;
  795. }}    regs.z = ((BYTE)(newv)) == 0;
  796.     regs.n = ((BYTE)(newv)) < 0;
  797.     put_byte(dsta,newv);
  798. }}}}}}}}}
  799. void op_9110(UWORD opcode)
  800. {
  801.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  802.     ULONG dstreg = (opcode & 7) >> 0;
  803. {{    BYTE src = regs.d[srcreg];
  804. {    CPTR dsta = regs.a[dstreg];
  805.     BYTE dst = get_byte(dsta);
  806. {    ULONG newv = dst - src;
  807. {    bool flgs = ((BYTE)(src)) < 0;
  808.     bool flgo = ((BYTE)(dst)) < 0;
  809.     bool flgn = ((BYTE)(newv)) < 0;
  810.     regs.z = ((BYTE)(newv)) == 0;
  811.     regs.v = (flgs != flgo) && (flgn != flgo);
  812.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  813.     regs.n = flgn != 0;
  814.     put_byte(dsta,newv);
  815. }}}}}}
  816. void op_9118(UWORD opcode)
  817. {
  818.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  819.     ULONG dstreg = (opcode & 7) >> 0;
  820. {{    BYTE src = regs.d[srcreg];
  821. {    CPTR dsta = regs.a[dstreg];
  822.     BYTE dst = get_byte(dsta);
  823. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  824. {    ULONG newv = dst - src;
  825. {    bool flgs = ((BYTE)(src)) < 0;
  826.     bool flgo = ((BYTE)(dst)) < 0;
  827.     bool flgn = ((BYTE)(newv)) < 0;
  828.     regs.z = ((BYTE)(newv)) == 0;
  829.     regs.v = (flgs != flgo) && (flgn != flgo);
  830.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  831.     regs.n = flgn != 0;
  832.     put_byte(dsta,newv);
  833. }}}}}}}
  834. void op_9120(UWORD opcode)
  835. {
  836.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  837.     ULONG dstreg = (opcode & 7) >> 0;
  838. {{    BYTE src = regs.d[srcreg];
  839. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  840. {    CPTR dsta = regs.a[dstreg];
  841.     BYTE dst = get_byte(dsta);
  842. {    ULONG newv = dst - src;
  843. {    bool flgs = ((BYTE)(src)) < 0;
  844.     bool flgo = ((BYTE)(dst)) < 0;
  845.     bool flgn = ((BYTE)(newv)) < 0;
  846.     regs.z = ((BYTE)(newv)) == 0;
  847.     regs.v = (flgs != flgo) && (flgn != flgo);
  848.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  849.     regs.n = flgn != 0;
  850.     put_byte(dsta,newv);
  851. }}}}}}}
  852. void op_9128(UWORD opcode)
  853. {
  854.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  855.     ULONG dstreg = (opcode & 7) >> 0;
  856. {{    BYTE src = regs.d[srcreg];
  857. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  858.     BYTE dst = get_byte(dsta);
  859. {    ULONG newv = dst - src;
  860. {    bool flgs = ((BYTE)(src)) < 0;
  861.     bool flgo = ((BYTE)(dst)) < 0;
  862.     bool flgn = ((BYTE)(newv)) < 0;
  863.     regs.z = ((BYTE)(newv)) == 0;
  864.     regs.v = (flgs != flgo) && (flgn != flgo);
  865.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  866.     regs.n = flgn != 0;
  867.     put_byte(dsta,newv);
  868. }}}}}}
  869. void op_9130(UWORD opcode)
  870. {
  871.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  872.     ULONG dstreg = (opcode & 7) >> 0;
  873. {{    BYTE src = regs.d[srcreg];
  874. {    CPTR dsta = regs.a[dstreg];
  875.     UWORD dstdp = nextiword();
  876.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  877. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  878.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  879.     dsta += dstdpr;
  880. {    BYTE dst = get_byte(dsta);
  881. {    ULONG newv = dst - src;
  882. {    bool flgs = ((BYTE)(src)) < 0;
  883.     bool flgo = ((BYTE)(dst)) < 0;
  884.     bool flgn = ((BYTE)(newv)) < 0;
  885.     regs.z = ((BYTE)(newv)) == 0;
  886.     regs.v = (flgs != flgo) && (flgn != flgo);
  887.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  888.     regs.n = flgn != 0;
  889.     put_byte(dsta,newv);
  890. }}}}}}}}
  891. void op_9138(UWORD opcode)
  892. {
  893.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  894. {{    BYTE src = regs.d[srcreg];
  895. {    CPTR dsta = (LONG)(WORD)nextiword();
  896.     BYTE dst = get_byte(dsta);
  897. {    ULONG newv = dst - src;
  898. {    bool flgs = ((BYTE)(src)) < 0;
  899.     bool flgo = ((BYTE)(dst)) < 0;
  900.     bool flgn = ((BYTE)(newv)) < 0;
  901.     regs.z = ((BYTE)(newv)) == 0;
  902.     regs.v = (flgs != flgo) && (flgn != flgo);
  903.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  904.     regs.n = flgn != 0;
  905.     put_byte(dsta,newv);
  906. }}}}}}
  907. void op_9139(UWORD opcode)
  908. {
  909.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  910. {{    BYTE src = regs.d[srcreg];
  911. {    CPTR dsta = nextilong();
  912.     BYTE dst = get_byte(dsta);
  913. {    ULONG newv = dst - src;
  914. {    bool flgs = ((BYTE)(src)) < 0;
  915.     bool flgo = ((BYTE)(dst)) < 0;
  916.     bool flgn = ((BYTE)(newv)) < 0;
  917.     regs.z = ((BYTE)(newv)) == 0;
  918.     regs.v = (flgs != flgo) && (flgn != flgo);
  919.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  920.     regs.n = flgn != 0;
  921.     put_byte(dsta,newv);
  922. }}}}}}
  923. void op_9140(UWORD opcode)
  924. {
  925.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  926.     ULONG dstreg = (opcode & 3584) >> 9;
  927. {{    WORD src = regs.d[srcreg];
  928. {    WORD dst = regs.d[dstreg];
  929. {    bool xflg = regs.x;
  930.     regs.v = regs.c = regs.x = 0;
  931. {    ULONG newv = dst - src;
  932. {    bool flgs = ((WORD)(src)) < 0;
  933.     bool flgo = ((WORD)(dst)) < 0;
  934.     bool flgn = ((WORD)(newv)) < 0;
  935.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  936.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  937.     if (xflg)
  938. {{    bool flgs = ((WORD)(1)) < 0;
  939.     bool flgo = ((WORD)(newv)) < 0;
  940.     bool flgn = ((WORD)((newv-1))) < 0;
  941.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  942.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  943.     newv--;
  944. }}    regs.z = ((WORD)(newv)) == 0;
  945.     regs.n = ((WORD)(newv)) < 0;
  946.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  947. }}}}}}}
  948. void op_9148(UWORD opcode)
  949. {
  950.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  951.     ULONG dstreg = (opcode & 3584) >> 9;
  952. {{    regs.a[srcreg] -= 2;
  953. {    CPTR srca = regs.a[srcreg];
  954.     WORD src = get_word(srca);
  955. {    regs.a[dstreg] -= 2;
  956. {    CPTR dsta = regs.a[dstreg];
  957.     WORD dst = get_word(dsta);
  958. {    bool xflg = regs.x;
  959.     regs.v = regs.c = regs.x = 0;
  960. {    ULONG newv = dst - src;
  961. {    bool flgs = ((WORD)(src)) < 0;
  962.     bool flgo = ((WORD)(dst)) < 0;
  963.     bool flgn = ((WORD)(newv)) < 0;
  964.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  965.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  966.     if (xflg)
  967. {{    bool flgs = ((WORD)(1)) < 0;
  968.     bool flgo = ((WORD)(newv)) < 0;
  969.     bool flgn = ((WORD)((newv-1))) < 0;
  970.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  971.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  972.     newv--;
  973. }}    regs.z = ((WORD)(newv)) == 0;
  974.     regs.n = ((WORD)(newv)) < 0;
  975.     put_word(dsta,newv);
  976. }}}}}}}}}
  977. void op_9150(UWORD opcode)
  978. {
  979.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  980.     ULONG dstreg = (opcode & 7) >> 0;
  981. {{    WORD src = regs.d[srcreg];
  982. {    CPTR dsta = regs.a[dstreg];
  983.     WORD dst = get_word(dsta);
  984. {    ULONG newv = dst - src;
  985. {    bool flgs = ((WORD)(src)) < 0;
  986.     bool flgo = ((WORD)(dst)) < 0;
  987.     bool flgn = ((WORD)(newv)) < 0;
  988.     regs.z = ((WORD)(newv)) == 0;
  989.     regs.v = (flgs != flgo) && (flgn != flgo);
  990.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  991.     regs.n = flgn != 0;
  992.     put_word(dsta,newv);
  993. }}}}}}
  994. void op_9158(UWORD opcode)
  995. {
  996.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  997.     ULONG dstreg = (opcode & 7) >> 0;
  998. {{    WORD src = regs.d[srcreg];
  999. {    CPTR dsta = regs.a[dstreg];
  1000.     WORD dst = get_word(dsta);
  1001. {    regs.a[dstreg] += 2;
  1002. {    ULONG newv = dst - src;
  1003. {    bool flgs = ((WORD)(src)) < 0;
  1004.     bool flgo = ((WORD)(dst)) < 0;
  1005.     bool flgn = ((WORD)(newv)) < 0;
  1006.     regs.z = ((WORD)(newv)) == 0;
  1007.     regs.v = (flgs != flgo) && (flgn != flgo);
  1008.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1009.     regs.n = flgn != 0;
  1010.     put_word(dsta,newv);
  1011. }}}}}}}
  1012. void op_9160(UWORD opcode)
  1013. {
  1014.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1015.     ULONG dstreg = (opcode & 7) >> 0;
  1016. {{    WORD src = regs.d[srcreg];
  1017. {    regs.a[dstreg] -= 2;
  1018. {    CPTR dsta = regs.a[dstreg];
  1019.     WORD dst = get_word(dsta);
  1020. {    ULONG newv = dst - src;
  1021. {    bool flgs = ((WORD)(src)) < 0;
  1022.     bool flgo = ((WORD)(dst)) < 0;
  1023.     bool flgn = ((WORD)(newv)) < 0;
  1024.     regs.z = ((WORD)(newv)) == 0;
  1025.     regs.v = (flgs != flgo) && (flgn != flgo);
  1026.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1027.     regs.n = flgn != 0;
  1028.     put_word(dsta,newv);
  1029. }}}}}}}
  1030. void op_9168(UWORD opcode)
  1031. {
  1032.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1033.     ULONG dstreg = (opcode & 7) >> 0;
  1034. {{    WORD src = regs.d[srcreg];
  1035. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1036.     WORD dst = get_word(dsta);
  1037. {    ULONG newv = dst - src;
  1038. {    bool flgs = ((WORD)(src)) < 0;
  1039.     bool flgo = ((WORD)(dst)) < 0;
  1040.     bool flgn = ((WORD)(newv)) < 0;
  1041.     regs.z = ((WORD)(newv)) == 0;
  1042.     regs.v = (flgs != flgo) && (flgn != flgo);
  1043.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1044.     regs.n = flgn != 0;
  1045.     put_word(dsta,newv);
  1046. }}}}}}
  1047. void op_9170(UWORD opcode)
  1048. {
  1049.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1050.     ULONG dstreg = (opcode & 7) >> 0;
  1051. {{    WORD src = regs.d[srcreg];
  1052. {    CPTR dsta = regs.a[dstreg];
  1053.     UWORD dstdp = nextiword();
  1054.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1055. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1056.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1057.     dsta += dstdpr;
  1058. {    WORD dst = get_word(dsta);
  1059. {    ULONG newv = dst - src;
  1060. {    bool flgs = ((WORD)(src)) < 0;
  1061.     bool flgo = ((WORD)(dst)) < 0;
  1062.     bool flgn = ((WORD)(newv)) < 0;
  1063.     regs.z = ((WORD)(newv)) == 0;
  1064.     regs.v = (flgs != flgo) && (flgn != flgo);
  1065.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1066.     regs.n = flgn != 0;
  1067.     put_word(dsta,newv);
  1068. }}}}}}}}
  1069. void op_9178(UWORD opcode)
  1070. {
  1071.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1072. {{    WORD src = regs.d[srcreg];
  1073. {    CPTR dsta = (LONG)(WORD)nextiword();
  1074.     WORD dst = get_word(dsta);
  1075. {    ULONG newv = dst - src;
  1076. {    bool flgs = ((WORD)(src)) < 0;
  1077.     bool flgo = ((WORD)(dst)) < 0;
  1078.     bool flgn = ((WORD)(newv)) < 0;
  1079.     regs.z = ((WORD)(newv)) == 0;
  1080.     regs.v = (flgs != flgo) && (flgn != flgo);
  1081.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1082.     regs.n = flgn != 0;
  1083.     put_word(dsta,newv);
  1084. }}}}}}
  1085. void op_9179(UWORD opcode)
  1086. {
  1087.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1088. {{    WORD src = regs.d[srcreg];
  1089. {    CPTR dsta = nextilong();
  1090.     WORD dst = get_word(dsta);
  1091. {    ULONG newv = dst - src;
  1092. {    bool flgs = ((WORD)(src)) < 0;
  1093.     bool flgo = ((WORD)(dst)) < 0;
  1094.     bool flgn = ((WORD)(newv)) < 0;
  1095.     regs.z = ((WORD)(newv)) == 0;
  1096.     regs.v = (flgs != flgo) && (flgn != flgo);
  1097.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1098.     regs.n = flgn != 0;
  1099.     put_word(dsta,newv);
  1100. }}}}}}
  1101. void op_9180(UWORD opcode)
  1102. {
  1103.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1104.     ULONG dstreg = (opcode & 3584) >> 9;
  1105. {{    LONG src = regs.d[srcreg];
  1106. {    LONG dst = regs.d[dstreg];
  1107. {    bool xflg = regs.x;
  1108.     regs.v = regs.c = regs.x = 0;
  1109. {    ULONG newv = dst - src;
  1110. {    bool flgs = ((LONG)(src)) < 0;
  1111.     bool flgo = ((LONG)(dst)) < 0;
  1112.     bool flgn = ((LONG)(newv)) < 0;
  1113.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  1114.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  1115.     if (xflg)
  1116. {{    bool flgs = ((LONG)(1)) < 0;
  1117.     bool flgo = ((LONG)(newv)) < 0;
  1118.     bool flgn = ((LONG)((newv-1))) < 0;
  1119.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  1120.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  1121.     newv--;
  1122. }}    regs.z = ((LONG)(newv)) == 0;
  1123.     regs.n = ((LONG)(newv)) < 0;
  1124.     regs.d[dstreg] = (newv);
  1125. }}}}}}}
  1126. void op_9188(UWORD opcode)
  1127. {
  1128.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1129.     ULONG dstreg = (opcode & 3584) >> 9;
  1130. {{    regs.a[srcreg] -= 4;
  1131. {    CPTR srca = regs.a[srcreg];
  1132.     LONG src = get_long(srca);
  1133. {    regs.a[dstreg] -= 4;
  1134. {    CPTR dsta = regs.a[dstreg];
  1135.     LONG dst = get_long(dsta);
  1136. {    bool xflg = regs.x;
  1137.     regs.v = regs.c = regs.x = 0;
  1138. {    ULONG newv = dst - src;
  1139. {    bool flgs = ((LONG)(src)) < 0;
  1140.     bool flgo = ((LONG)(dst)) < 0;
  1141.     bool flgn = ((LONG)(newv)) < 0;
  1142.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  1143.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  1144.     if (xflg)
  1145. {{    bool flgs = ((LONG)(1)) < 0;
  1146.     bool flgo = ((LONG)(newv)) < 0;
  1147.     bool flgn = ((LONG)((newv-1))) < 0;
  1148.     if ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;
  1149.     if ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;
  1150.     newv--;
  1151. }}    regs.z = ((LONG)(newv)) == 0;
  1152.     regs.n = ((LONG)(newv)) < 0;
  1153.     put_long(dsta,newv);
  1154. }}}}}}}}}
  1155. void op_9190(UWORD opcode)
  1156. {
  1157.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1158.     ULONG dstreg = (opcode & 7) >> 0;
  1159. {{    LONG src = regs.d[srcreg];
  1160. {    CPTR dsta = regs.a[dstreg];
  1161.     LONG dst = get_long(dsta);
  1162. {    ULONG newv = dst - src;
  1163. {    bool flgs = ((LONG)(src)) < 0;
  1164.     bool flgo = ((LONG)(dst)) < 0;
  1165.     bool flgn = ((LONG)(newv)) < 0;
  1166.     regs.z = ((LONG)(newv)) == 0;
  1167.     regs.v = (flgs != flgo) && (flgn != flgo);
  1168.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1169.     regs.n = flgn != 0;
  1170.     put_long(dsta,newv);
  1171. }}}}}}
  1172. void op_9198(UWORD opcode)
  1173. {
  1174.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1175.     ULONG dstreg = (opcode & 7) >> 0;
  1176. {{    LONG src = regs.d[srcreg];
  1177. {    CPTR dsta = regs.a[dstreg];
  1178.     LONG dst = get_long(dsta);
  1179. {    regs.a[dstreg] += 4;
  1180. {    ULONG newv = dst - src;
  1181. {    bool flgs = ((LONG)(src)) < 0;
  1182.     bool flgo = ((LONG)(dst)) < 0;
  1183.     bool flgn = ((LONG)(newv)) < 0;
  1184.     regs.z = ((LONG)(newv)) == 0;
  1185.     regs.v = (flgs != flgo) && (flgn != flgo);
  1186.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1187.     regs.n = flgn != 0;
  1188.     put_long(dsta,newv);
  1189. }}}}}}}
  1190. void op_91a0(UWORD opcode)
  1191. {
  1192.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1193.     ULONG dstreg = (opcode & 7) >> 0;
  1194. {{    LONG src = regs.d[srcreg];
  1195. {    regs.a[dstreg] -= 4;
  1196. {    CPTR dsta = regs.a[dstreg];
  1197.     LONG dst = get_long(dsta);
  1198. {    ULONG newv = dst - src;
  1199. {    bool flgs = ((LONG)(src)) < 0;
  1200.     bool flgo = ((LONG)(dst)) < 0;
  1201.     bool flgn = ((LONG)(newv)) < 0;
  1202.     regs.z = ((LONG)(newv)) == 0;
  1203.     regs.v = (flgs != flgo) && (flgn != flgo);
  1204.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1205.     regs.n = flgn != 0;
  1206.     put_long(dsta,newv);
  1207. }}}}}}}
  1208. void op_91a8(UWORD opcode)
  1209. {
  1210.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1211.     ULONG dstreg = (opcode & 7) >> 0;
  1212. {{    LONG src = regs.d[srcreg];
  1213. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1214.     LONG dst = get_long(dsta);
  1215. {    ULONG newv = dst - src;
  1216. {    bool flgs = ((LONG)(src)) < 0;
  1217.     bool flgo = ((LONG)(dst)) < 0;
  1218.     bool flgn = ((LONG)(newv)) < 0;
  1219.     regs.z = ((LONG)(newv)) == 0;
  1220.     regs.v = (flgs != flgo) && (flgn != flgo);
  1221.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1222.     regs.n = flgn != 0;
  1223.     put_long(dsta,newv);
  1224. }}}}}}
  1225. void op_91b0(UWORD opcode)
  1226. {
  1227.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1228.     ULONG dstreg = (opcode & 7) >> 0;
  1229. {{    LONG src = regs.d[srcreg];
  1230. {    CPTR dsta = regs.a[dstreg];
  1231.     UWORD dstdp = nextiword();
  1232.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1233. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1234.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1235.     dsta += dstdpr;
  1236. {    LONG dst = get_long(dsta);
  1237. {    ULONG newv = dst - src;
  1238. {    bool flgs = ((LONG)(src)) < 0;
  1239.     bool flgo = ((LONG)(dst)) < 0;
  1240.     bool flgn = ((LONG)(newv)) < 0;
  1241.     regs.z = ((LONG)(newv)) == 0;
  1242.     regs.v = (flgs != flgo) && (flgn != flgo);
  1243.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1244.     regs.n = flgn != 0;
  1245.     put_long(dsta,newv);
  1246. }}}}}}}}
  1247. void op_91b8(UWORD opcode)
  1248. {
  1249.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1250. {{    LONG src = regs.d[srcreg];
  1251. {    CPTR dsta = (LONG)(WORD)nextiword();
  1252.     LONG dst = get_long(dsta);
  1253. {    ULONG newv = dst - src;
  1254. {    bool flgs = ((LONG)(src)) < 0;
  1255.     bool flgo = ((LONG)(dst)) < 0;
  1256.     bool flgn = ((LONG)(newv)) < 0;
  1257.     regs.z = ((LONG)(newv)) == 0;
  1258.     regs.v = (flgs != flgo) && (flgn != flgo);
  1259.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1260.     regs.n = flgn != 0;
  1261.     put_long(dsta,newv);
  1262. }}}}}}
  1263. void op_91b9(UWORD opcode)
  1264. {
  1265.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  1266. {{    LONG src = regs.d[srcreg];
  1267. {    CPTR dsta = nextilong();
  1268.     LONG dst = get_long(dsta);
  1269. {    ULONG newv = dst - src;
  1270. {    bool flgs = ((LONG)(src)) < 0;
  1271.     bool flgo = ((LONG)(dst)) < 0;
  1272.     bool flgn = ((LONG)(newv)) < 0;
  1273.     regs.z = ((LONG)(newv)) == 0;
  1274.     regs.v = (flgs != flgo) && (flgn != flgo);
  1275.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1276.     regs.n = flgn != 0;
  1277.     put_long(dsta,newv);
  1278. }}}}}}
  1279. void op_91c0(UWORD opcode)
  1280. {
  1281.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1282.     ULONG dstreg = (opcode & 3584) >> 9;
  1283. {{    LONG src = regs.d[srcreg];
  1284. {    LONG dst = regs.a[dstreg];
  1285. {    ULONG newv = dst - src;
  1286.     regs.a[dstreg] = (newv);
  1287. }}}}}
  1288. void op_91c8(UWORD opcode)
  1289. {
  1290.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1291.     ULONG dstreg = (opcode & 3584) >> 9;
  1292. {{    LONG src = regs.a[srcreg];
  1293. {    LONG dst = regs.a[dstreg];
  1294. {    ULONG newv = dst - src;
  1295.     regs.a[dstreg] = (newv);
  1296. }}}}}
  1297. void op_91d0(UWORD opcode)
  1298. {
  1299.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1300.     ULONG dstreg = (opcode & 3584) >> 9;
  1301. {{    CPTR srca = regs.a[srcreg];
  1302.     LONG src = get_long(srca);
  1303. {    LONG dst = regs.a[dstreg];
  1304. {    ULONG newv = dst - src;
  1305.     regs.a[dstreg] = (newv);
  1306. }}}}}
  1307. void op_91d8(UWORD opcode)
  1308. {
  1309.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1310.     ULONG dstreg = (opcode & 3584) >> 9;
  1311. {{    CPTR srca = regs.a[srcreg];
  1312.     LONG src = get_long(srca);
  1313. {    regs.a[srcreg] += 4;
  1314. {    LONG dst = regs.a[dstreg];
  1315. {    ULONG newv = dst - src;
  1316.     regs.a[dstreg] = (newv);
  1317. }}}}}}
  1318. void op_91e0(UWORD opcode)
  1319. {
  1320.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1321.     ULONG dstreg = (opcode & 3584) >> 9;
  1322. {{    regs.a[srcreg] -= 4;
  1323. {    CPTR srca = regs.a[srcreg];
  1324.     LONG src = get_long(srca);
  1325. {    LONG dst = regs.a[dstreg];
  1326. {    ULONG newv = dst - src;
  1327.     regs.a[dstreg] = (newv);
  1328. }}}}}}
  1329. void op_91e8(UWORD opcode)
  1330. {
  1331.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1332.     ULONG dstreg = (opcode & 3584) >> 9;
  1333. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  1334.     LONG src = get_long(srca);
  1335. {    LONG dst = regs.a[dstreg];
  1336. {    ULONG newv = dst - src;
  1337.     regs.a[dstreg] = (newv);
  1338. }}}}}
  1339. void op_91f0(UWORD opcode)
  1340. {
  1341.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1342.     ULONG dstreg = (opcode & 3584) >> 9;
  1343. {{    CPTR srca = regs.a[srcreg];
  1344.     UWORD srcdp = nextiword();
  1345.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  1346. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  1347.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  1348.     srca += srcdpr;
  1349. {    LONG src = get_long(srca);
  1350. {    LONG dst = regs.a[dstreg];
  1351. {    ULONG newv = dst - src;
  1352.     regs.a[dstreg] = (newv);
  1353. }}}}}}}
  1354. void op_91f8(UWORD opcode)
  1355. {
  1356.     ULONG dstreg = (opcode & 3584) >> 9;
  1357. {{    CPTR srca = (LONG)(WORD)nextiword();
  1358.     LONG src = get_long(srca);
  1359. {    LONG dst = regs.a[dstreg];
  1360. {    ULONG newv = dst - src;
  1361.     regs.a[dstreg] = (newv);
  1362. }}}}}
  1363. void op_91f9(UWORD opcode)
  1364. {
  1365.     ULONG dstreg = (opcode & 3584) >> 9;
  1366. {{    CPTR srca = nextilong();
  1367.     LONG src = get_long(srca);
  1368. {    LONG dst = regs.a[dstreg];
  1369. {    ULONG newv = dst - src;
  1370.     regs.a[dstreg] = (newv);
  1371. }}}}}
  1372. void op_91fa(UWORD opcode)
  1373. {
  1374.     ULONG dstreg = (opcode & 3584) >> 9;
  1375. {{    CPTR srca = m68k_getpc();
  1376.     srca += (LONG)(WORD)nextiword();
  1377. {    LONG src = get_long(srca);
  1378. {    LONG dst = regs.a[dstreg];
  1379. {    ULONG newv = dst - src;
  1380.     regs.a[dstreg] = (newv);
  1381. }}}}}}
  1382. void op_91fb(UWORD opcode)
  1383. {
  1384.     ULONG dstreg = (opcode & 3584) >> 9;
  1385. {{    CPTR srca = m68k_getpc();
  1386.     UWORD srcdp = nextiword();
  1387.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  1388. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  1389.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  1390.     srca += srcdpr;
  1391. {    LONG src = get_long(srca);
  1392. {    LONG dst = regs.a[dstreg];
  1393. {    ULONG newv = dst - src;
  1394.     regs.a[dstreg] = (newv);
  1395. }}}}}}}
  1396. void op_91fc(UWORD opcode)
  1397. {
  1398.     ULONG dstreg = (opcode & 3584) >> 9;
  1399. {{    LONG src = nextilong();
  1400. {    LONG dst = regs.a[dstreg];
  1401. {    ULONG newv = dst - src;
  1402.     regs.a[dstreg] = (newv);
  1403. }}}}}
  1404.